import copy  # 导入拷贝模块

# 有关深浅场景的界定
# 普通的列表拷贝
# 1. copy.copy(对象) 进行的是浅拷贝
#    1. 比如：列表为： [10, 20, 30, 40],  就是简单拷贝，不存在深拷贝和浅拷贝问题
#    2. 比如：嵌套列表：[[10, 20, 30], [40, 50, 60]], 会存在深拷贝和浅拷贝问题
# 2. 对可变类型，可能需要对其拷贝。
# 3. 针对不可变类型，很少对这种类型进行拷贝。




# python的赋值操作属于引用赋值(eg:b是a的别名, 形参是实参的别名)
def dm01_普通赋值():

    # 1 python中的赋值操作, 属于引用赋值 (把a的地址赋值给b)
    # 2 b是a的别名, b和a都指向相同的内存空间
    a = 10
    b = a  # 引用
    print('id(a)-->', id(a))
    print('id(b)-->', id(b))
    print('id(10)-->', id(10))

    # 3 也是引用赋值 c和d指向相同的内存空间
    a = [1, 2, 3]
    b = [11, 22, 33]
    c = [a, b]  # [[1,2,3],[11,22,33]]
    d = c
    print('id(c)-->', id(c))
    print('id(d)-->', id(d))

    # 4 值的方式赋值 a 指向一块内存空间、b 也指向一块内存空间
    # b = a python中不支持, 这样做传参效率高


# 浅拷贝可变类型: 只拷贝第1层数据, 深层次数据不拷贝
def dm02_浅拷贝可变类型():
    a = [1, 2, 3]
    b = [11, 22, 33]
    c = [6, 7, a, b]

    # 测试1 id(c)和id(d)
    d = copy.copy(c)
    print('id(c)-->', id(c))
    print('id(d)-->', id(d))
    print("id(c)和id(d)值不一样, 说明浅拷贝第1层(最外面一层的数据)")

    # 测试2
    print(id(c[2]))
    print(id(a))
    print("id(c[2])和id(a)值一样, 说明浅拷贝第2层的数据")

    # 修改a[2] = 22
    a[2] = 22
    print('c->', c)
    print('d->', d)
    pass


# 浅拷贝不可变类型: 不会给拷贝的对象c开辟新的内存空间,
# 而只是拷贝了这个对象的引用
def dm03_浅拷贝不可变类型():

    # 不可变类型 a b c
    a = (1, 2, 3)
    b = (11, 22, 33)
    c = (6, 7, a, b)

    d = copy.copy(c)
    print('id(c)-->', id(c))
    print('id(d)-->', id(d))
    print("id(c)和id(d)值一样, 说明c和d指向相同的内存空间")
    # 不可变类型本身值都是不能被修改的,没有再浪费内存空,
    # 所以程序员要浅拷贝不可变类型,
    # python解释器直接返回值地址(别名/引用)
    pass


def mybase():
    s1 = "abc"
    print(id(s1))

    s2 = "efg"
    print(id(s2))

    s1 = s1 + "aa"
    print(id(s1))

if __name__ == '__main__':
    # mybase()
    # dm01_普通赋值()

    # dm02_浅拷贝可变类型()

    dm03_浅拷贝不可变类型()
    pass











